package lei.h_java8特性.lambda表达式;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

/**
 * @className: JavaLamdba
 * @author: xl
 * @date: 2025/3/1 15:12
 * @Version: 1.0
 * @description:
 *
 *
 * 1. Lambda 表达式的基本语法
 * Lambda 表达式的语法如下：  (参数列表) -> { 方法体 }
 *
 * 如果方法体只有一行代码，可以省略 {} 和 return。
 * 如果参数列表只有一个参数，可以省略 ()。
 *
 * ✅ 适用条件
 * 函数式接口（Functional Interface）
 * 必须是仅包含一个抽象方法的接口（如 Runnable、Comparator、Consumer 等）
 */

public class LambdaExample01 {
    public static void main(String[] args) {
        // 传统方式：使用匿名内部类
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello, World!");
            }
        };

        //新建一个线程并启动他  且返回类型必须是Runnable
        new Thread(runnable1).start();



        // 使用 Lambda 表达式
        Runnable runnable2 = () -> System.out.println("Hello, Lambda!");
        new Thread(runnable2).start();





        List<String> languages = Arrays.asList("Java", "Python", "C++", "JavaScript");

        // 传统方式：使用匿名内部类

        /**
         *     default void sort(Comparator<? super E> c) {
         *         Object[] a = this.toArray();
         *         Arrays.sort(a, (Comparator) c);
         *         ListIterator<E> i = this.listIterator();
         *         for (Object e : a) {
         *             i.next();
         *             i.set((E) e);
         *         }
         *     }
         *
         *     Comparator里面只有一个compare的抽象方法方法
         *     函数式接口的抽象方法数量不包括：
         *          默认方法  带 default
         *          静态方法  带 static
         *          从 Object 类继承的 public 方法
         */
        languages.sort(new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        });

        // 使用 Lambda 表达式
        languages.sort((s1, s2) -> s1.length() - s2.length());

        System.out.println(languages); // 输出: [C++, Java, Python, JavaScript]


    }
}
